package templateDesigner

import util.*
import grails.converters.*
import groovy.xml.MarkupBuilder

class TemplateController {

    def templateService
    
    
    //--------------------------------------------------------------------------
    
    def index = { }
    
    //--------------------------------------------------------------------------
    
    def crear = {
        Template temp = new Template(identif: params["id"], nombre: params["nombre"], path: "")
        if (!temp.save()){ println "ERROR" + temp.errors } else { println "OK Guardado Template" }

        String xmlTempl = templateService.crearXMLTemplateInicial(params["id"], params["nombre"], params["nombreArchivoLayout"])

        Edicion edic = crearEdiciónTempate(xmlTempl, "1", temp)

        // Guardo la instancia de la edicion en la sesión
        ((TDSession)(session.templateDesignContext)).edicionActual = edic
        
        def edicionActual = [
                pathLayout: params["pathLayout"],
                nombreArchivoLayout: params["nombreArchivoLayout"],
                versionLayout: params["versionLayout"],
                nombreTemplate: params["nombre"],
                id: params["id"]
        ]
        
        //render params["nombre"]
        render edicionActual as JSON
    }
    
    //--------------------------------------------------------------------------
    
    def abrirLocal = {
        var identifTemplate = params["identifTemplate"]
        var numVersion = params["numVersion"]
        
        Template templ = Template.findByIdentif(identifTemplate)
        VersionTemplate versTempl = templ.versionTemplate.find{ v -> v.numero.equals(numVersion) }
        Edicion edic = versTempl.edicion
        
        // Guardo la instancia de la edicion en la sesión
        ((TDSession)(session.templateDesignContext)).edicionActual = edic
        
        render(contentType:'text/json') {
            estructuraTemplate() // TODO, Crear a partir de xml Template
        }
    }
    
    //--------------------------------------------------------------------------
    
    def abrirRemoto = {
        var identifTemplate = params["identifTemplate"]
        var path = params["path"]
        var numVersion = params["numVersion"]
        
        // Pido el Template al repositorio
        def templRemoto = templateService.getTemplate(identifTemplate, numVersion, path)
        String contenido = new String(templRemoto.contenido.value.decodeBase64())
        
        render(contentType:'text/json') {
            estructuraTemplate() // TODO, Crear a partir de xml Template
        }
    }
    
    //--------------------------------------------------------------------------
    
    /*def guardar = {
        //def estructura = JSON.parse(params);
        println "AA2: " + params["zones[zona1][archetype]"]
    }*/
    
    def guardar = {
        
        def datosTemplate = JSON.parse(params.datosTemplate)     
        def xmlTemplate = templateService.crearXMLTemplate(datosTemplate)
        
        println "XML: " + xmlTemplate //(datosTemplate as XML)   
        
        def errores = ""
        
        // Obtengo de la sesión la instancia de edicion a editar
        Edicion edic = ((TDSession)(session.templateDesignContext)).edicionActual
        edic = Edicion.get(edic.id) // Hago esto para evitar el error hibernate.LazyInitializationException (para objetos guardados en la sesión en otra petición HTTP)
        if (datosTemplate.versionTemplate != edic.versionTemplate.numero){
            // Se crea una nueva Versión de Edición
            edic = crearEdiciónTempate(xmlTemplate, datosTemplate.versionTemplate, edic.versionTemplate.template)
            if (edic == null){
                errores = "Error al guardar"
            }
        }
        else{
            edic.xmlTemplate = xmlTemplate
            
            //edic.save()
            edic = edic.merge()
            
            //if(!edic.save()){
            //    errores = edic.errors
            //    println "ERROR" + edic.errors
            //}
        }
        
        if (errores == ""){
            // Actualizo la edicion actual en la sesión
            ((TDSession)(session.templateDesignContext)).edicionActual = null;
            ((TDSession)(session.templateDesignContext)).edicionActual = edic
        }
        
        render (contentType: 'text/json'){
            resultado(versionTemplate: datosTemplate.versionTemplate, error: errores)
        }
    }  
                    
    //--------------------------------------------------------------------------
    
    def consolidar = {
        
        def datosTemplate = JSON.parse(params.datosTemplate) 
        def path = datosTemplate.pathTemplate
        
        def xmlTemplate = templateService.crearXMLTemplate(datosTemplate)
        
        // Obtengo de la sesión la instancia de edicion a editar
        Edicion edic = ((TDSession)(session.templateDesignContext)).edicionActual
        edic = Edicion.get(edic.id)
        
        edic.xmlTemplate = xmlTemplate
        edic.finalizada = true 
        edic.versionTemplate.template.path = path
        
        def errores = ""
        edic = edic.merge()
        
        // TODO: Salvar en repositorio
        templateService.saveTemplate(edic)
        
        render (contentType: 'text/json'){
            resultado(error: errores)
        }
    }
    
    //--------------------------------------------------------------------------
    
    def edicionesTemplates = {
        def l = []
        def listadoEdiciones = Usuario.get(session.templateDesignContext.userId).ediciones
        listadoEdiciones.each{edic ->
            l.add([numeroVersion: edic.versionTemplate.numero, nombre: edic.versionTemplate.template.nombre , identif: edic.versionTemplate.template.identif])
        }

        render l as JSON
    }
    
    //--------------------------------------------------------------------------

    
    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    
    private Edicion crearEdiciónTempate(String xmlTempl, String numVersion, Template temp){
        Usuario usu = Usuario.findByNombre(((TDSession)(session.templateDesignContext)).userName)
        VersionTemplate vers = new VersionTemplate(numero: numVersion, descripcion: "", template: temp)
        Edicion edic = new Edicion(xmlTemplate: xmlTempl, notas: "", versionTemplate: vers, finalizada: false)
        vers.edicion = edic
        usu.addToEdiciones(edic)
        Edicion result = null;
        if (!usu.save()){
            println "ERROR" + usu.errors 
        } else{ 
            result = edic
            println "OK Guardado Usuario-Version-Edicion" 
        }
                        
        return result
    }
}
